oracle.pgx.api

## Class PgxGraph

- java.lang.Object
- - oracle.pgx.api.Destroyable
  - - oracle.pgx.api.PgxManagedObject
    - - oracle.pgx.api.PgxGraph

- All Implemented Interfaces:
    AutoCloseable
  Direct Known Subclasses:
    BipartiteGraph

      public class PgxGraph
      extends PgxManagedObject

  A PGX Graph

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `PgxGraph.Degree`
    `static class` | `PgxGraph.Direction`
    `static class` | `PgxGraph.Mode`
    `static class` | `PgxGraph.MultiEdges`
    `static class` | `PgxGraph.SelfEdges`
    `static class` | `PgxGraph.TrivialVertices`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `BipartiteGraph` | `bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
    `BipartiteGraph` | `bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName, String isLeftPropName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
    `BipartiteGraph` | `bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
    `BipartiteGraph` | `bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet, String newGraphName)` Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`.
    `PgxFuture<BipartiteGraph>` | `bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName)` Create a bipartite version of a graph.
    `PgxFuture<BipartiteGraph>` | `bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, VertexSet<?> vertexSet, String newGraphName, String isLeftPropName)`
    `PgxFuture<BipartiteGraph>` | `bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)` Create a bipartite version of a graph. `#bipartiteSubGraphFromLeftSet(Collection, Collection, VertexSet)` Passing vertexProps as `VertexProperty.ALL` edgeProps as `EdgeProperty.ALL`
    `PgxFuture<BipartiteGraph>` | `bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet, String newGraphName)` Create a bipartite version of a graph.
    `PgxGraph` | `clone()` Blocking version of `cloneAsync()`.
    `PgxGraph` | `clone(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, String newGraphName)` Blocking version of `cloneAsync()`.
    `PgxGraph` | `clone(String newGraphName)` Blocking version of `cloneAsync()`.
    `PgxFuture<PgxGraph>` | `cloneAsync()` Convenience method of `cloneAsync(String)` Passing String(name) as `null` Create a copy of a graph.
    `PgxFuture<PgxGraph>` | `cloneAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, String newGraphName)` Create a copy of a graph.
    `PgxFuture<PgxGraph>` | `cloneAsync(String newGraphName)` Convenience method of `cloneAsync(Collection, Collection, String)` Passing Collection(vertexProperties) as `VertexProperty.ALL` Collection(edgeProperties) as `EdgeProperty.ALL` Create a copy of a graph.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `createAllPaths(PgxVertex<ID> src, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `#createAllPathsAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `createAllPathsAsync(PgxVertex<ID> src, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Creates a `AllPaths` object representing all the shortest paths from a single source to all the possible destinations (shortest regarding the given edge costs).
    `<ID extends Comparable<ID>> Partition<ID>` | `createComponents(VertexProperty<ID,Integer> components, int numComponents)` Blocking version of `#createComponentsAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Partition<ID>>` | `createComponentsAsync(VertexProperty<ID,Integer> components, int numComponents)` Creates a `Partition` object holding a collection of vertex sets, each representing a component.
    `<V extends Comparable<V>> EdgeProperty<V>` | `createEdgeProperty(PropertyType type)` Blocking version of `#createEdgePropertyAsync()`.
    `<V extends Comparable<V>> EdgeProperty<V>` | `createEdgeProperty(PropertyType type, String name)` Blocking version of `#createEdgePropertyAsync()`.
    `<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>` | `createEdgePropertyAsync(PropertyType type)` Creates a session-bound edge property
    `<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>` | `createEdgePropertyAsync(PropertyType type, String name)` Creates a session-bound edge property
    `EdgeSequence` | `createEdgeSequence()` Blocking version of `createEdgeSequenceAsync()`.
    `EdgeSequence` | `createEdgeSequence(String name)` Blocking version of `createEdgeSequenceAsync()`.
    `PgxFuture<EdgeSequence>` | `createEdgeSequenceAsync()` Creates a new Edge Sequence.
    `PgxFuture<EdgeSequence>` | `createEdgeSequenceAsync(String name)` Creates a new Edge Sequence.
    `EdgeSet` | `createEdgeSet()` Blocking version of `createEdgeSetAsync()`.
    `EdgeSet` | `createEdgeSet(String name)` Blocking version of `createEdgeSetAsync()`.
    `PgxFuture<EdgeSet>` | `createEdgeSetAsync()` Creates a new Edge Set.
    `PgxFuture<EdgeSet>` | `createEdgeSetAsync(String name)` Creates a new Edge Set.
    `<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>` | `createMap(PropertyType keyType, PropertyType valType)` Blocking version of `#createMapAsync()`.
    `<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>` | `createMap(PropertyType keyType, PropertyType valType, MapType mapType)` Blocking version of `#createMapAsync()`.
    `<K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V>` | `createMap(PropertyType keyType, PropertyType valType, MapType mapType, String mapName)` Blocking version of `#createMapAsync()`.
    `<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>` | `createMapAsync(PropertyType keyType, PropertyType valType)` Creates a session-bound map
    `<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>` | `createMapAsync(PropertyType keyType, PropertyType valType, MapType mapType)` Creates a session-bound map
    `<K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>>` | `createMapAsync(PropertyType keyType, PropertyType valType, MapType mapType, String mapName)` Creates a session-bound map
    `<ID extends Comparable<ID>> PgxPath<ID>` | `createPath(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Blocking version of `#createPathAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>` | `createPathAsync(PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)` Creates a `PgxPath` object representing the shortest path from one source to one destination (shortest regarding the given edge costs).
    `<T> Scalar<T>` | `createScalar(PropertyType type)` Blocking version of `#createScalarAsync()`.
    `<T> Scalar<T>` | `createScalar(PropertyType type, String newScalarName)` Blocking version of `#createScalarAsync()`.
    `<T> PgxFuture<Scalar<T>>` | `createScalarAsync(PropertyType type)` Creates a new Scalar.
    `<T> PgxFuture<Scalar<T>>` | `createScalarAsync(PropertyType type, String newScalarName)` Create a session-bound scalar.
    `<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>` | `createVertexProperty(PropertyType type)` Blocking version of `#createVertexPropertyAsync()`.
    `<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>` | `createVertexProperty(PropertyType type, String name)` Blocking version of `#createVertexPropertyAsync()`.
    `<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>` | `createVertexPropertyAsync(PropertyType type)` Creates a session-bound vertex property
    `<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>` | `createVertexPropertyAsync(PropertyType type, String name)` Creates a session-bound vertex property
    `<E extends Comparable<E>> VertexSequence<E>` | `createVertexSequence()` Blocking version of `createVertexSequenceAsync()`.
    `<E extends Comparable<E>> VertexSequence<E>` | `createVertexSequence(String name)` Blocking version of `createVertexSequenceAsync()`.
    `<E extends Comparable<E>> PgxFuture<VertexSequence<E>>` | `createVertexSequenceAsync()` Creates a new Vertex Sequence.
    `<E extends Comparable<E>> PgxFuture<VertexSequence<E>>` | `createVertexSequenceAsync(String name)` Creates a new Vertex Sequence.
    `<E extends Comparable<E>> VertexSet<E>` | `createVertexSet()` Blocking version of `createVertexSetAsync()`.
    `<E extends Comparable<E>> VertexSet<E>` | `createVertexSet(String name)` Blocking version of `createVertexSetAsync()`.
    `<E extends Comparable<E>> PgxFuture<VertexSet<E>>` | `createVertexSetAsync()` Creates a new Vertex Set.
    `<E extends Comparable<E>> PgxFuture<VertexSet<E>>` | `createVertexSetAsync(String name)` Creates a new Vertex Set.
    `PgxGraph` | `filter(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, String newGraphName)` Blocking version of `#filterAsync()`.
    `PgxGraph` | `filter(GraphFilter graphFilter)` Blocking version of `#filterAsync()`.
    `PgxGraph` | `filter(GraphFilter graphFilter, String newGraphName)` Blocking version of `#filterAsync()`.
    `PgxFuture<PgxGraph>` | `filterAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, GraphFilter graphFilter, String newGraphName)` Create a subgraph of a graph.
    `PgxFuture<PgxGraph>` | `filterAsync(GraphFilter graphFilter)` Create a subgraph of a graph.
    `PgxFuture<PgxGraph>` | `filterAsync(GraphFilter graphFilter, String newGraphName)` Create a subgraph of a graph.
    `GraphConfig` | `getConfig()` Gets the graph configuration object used to specify the data source of this graph.
    `long` | `getCreationRequestTimestamp()` Gets the timestamp when this graph was requested to be created.
    `long` | `getCreationTimestamp()` Gets the timestamp when this graph finished creation.
    `String` | `getDataSourceVersion()` Gets the format-specific version identifier provided by data-source (timestamp for files, snapshot ID for databases).
    `PgxEdge` | `getEdge(long id)` Gets a `PgxEdge` of this graph by ID.
    `Set<EdgeProperty<?>>` | `getEdgeProperties()` Blocking version of `getEdgePropertiesAsync()`.
    `PgxFuture<Set<EdgeProperty<?>>>` | `getEdgePropertiesAsync()` Get the set of edge properties belonging to this graph.
    `<V extends Comparable<V>> EdgeProperty<V>` | `getEdgeProperty(String name)` Blocking version of `#getEdgePropertyAsync()`.
    `<V extends Comparable<V>> PgxFuture<EdgeProperty<V>>` | `getEdgePropertyAsync(String name)` get an edge property of this graph
    `EdgeSet` | `getEdges(EdgeFilter filter)` Blocking version of `#getEdges()`.
    `<E extends Comparable<E>> PgxFuture<EdgeSet>` | `getEdgesAsync(EdgeFilter filter)` Creates a new Edge Set containing edges according to the given filter expression.
    `long` | `getMemoryMb()` Gets the estimated number of memory this graph (including its properties) consumes in memory (in megabytes).
    `String` | `getName()`
    `long` | `getNumEdges()` Gets the number of edges
    `long` | `getNumVertices()` Gets the number of vertices
    `ServerInstance` | `getPgxInstance()`
    `PgxSession` | `getSession()`
    `<ID extends Comparable<ID>> PgxVertex<ID>` | `getVertex(ID id)` Gets a `PgxVertex` of this graph by ID.
    `IdType` | `getVertexIdType()` Gets the vertex ID type of this graph.
    `Set<VertexProperty<?,?>>` | `getVertexProperties()` Blocking version of `getVertexPropertiesAsync()`.
    `PgxFuture<Set<VertexProperty<?,?>>>` | `getVertexPropertiesAsync()` Get the set of vertex properties belonging to this graph.
    `<ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V>` | `getVertexProperty(String name)` Blocking version of `#getVertexPropertyAsync()`.
    `<ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>>` | `getVertexPropertyAsync(String name)` Gets a vertex property of this graph
    `<E extends Comparable<E>> VertexSet<E>` | `getVertices(VertexFilter filter)` Blocking version of `#getVerticesAsync()`.
    `<E extends Comparable<E>> PgxFuture<VertexSet<E>>` | `getVerticesAsync(VertexFilter filter)` Creates a new Vertex Set containing vertices according to the given filter expression.
    `boolean` | `isFresh()` Blocking version of `isFreshAsync()`.
    `PgxFuture<Boolean>` | `isFreshAsync()` Check whether an in-memory representation of a graph is fresh.
    `boolean` | `isTransient()`
    `<ID extends Comparable<ID>> PgxVertex<ID>` | `pickRandomVertex()` Blocking version of `pickRandomVertexAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxVertex<ID>>` | `pickRandomVertexAsync()` Picks a random vertex in the graph.
    `PgxGraph` | `simplify(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `#simplifyAsync()`.
    `PgxGraph` | `simplify(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `#simplifyAsync()`.
    `PgxFuture<PgxGraph>` | `simplifyAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Create a simplified version of a graph.
    `PgxFuture<PgxGraph>` | `simplifyAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Convenience method for `simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing Collection(vertexProperties) as `VertexProperty.ALL` Collection(edgeProperties) as `EdgeProperty.ALL` Create a simplified version of a graph.
    `PgxGraph` | `sortByDegree()` Blocking version of `sortByDegreeAsync()`.
    `PgxGraph` | `sortByDegree(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Blocking version of `sortByDegreeAsync()`.
    `PgxGraph` | `sortByDegree(PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Blocking version of `sortByDegreeAsync()`.
    `PgxGraph` | `sortByDegree(String newGraphName)` Blocking version of `sortByDegreeAsync()`.
    `PgxFuture<PgxGraph>` | `sortByDegreeAsync()` Create a sorted version of a graph and all its properties.
    `PgxFuture<PgxGraph>` | `sortByDegreeAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Create a sorted version of a graph and all its properties.
    `PgxFuture<PgxGraph>` | `sortByDegreeAsync(PgxGraph.Direction direction, PgxGraph.Degree degree, PgxGraph.Mode mode, String newGraphName)` Create a sorted version of a graph and all its properties.
    `PgxFuture<PgxGraph>` | `sortByDegreeAsync(String newGraphName)` Create a sorted version of a graph and all its properties.
    `PgxGraph` | `sparsify(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, double e, String newGraphName)` Blocking version of `#sparsifyAsync()`.
    `PgxGraph` | `sparsify(double e)` Blocking version of `#sparsifyAsync()`.
    `PgxGraph` | `sparsify(double e, String newGraphName)` Blocking version of `#sparsifyAsync()`.
    `PgxFuture<PgxGraph>` | `sparsifyAsync(Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, double e, String newGraphName)` Sparsifies the given graph and returns a new graph with less edges.
    `PgxFuture<PgxGraph>` | `sparsifyAsync(double e)` Sparsifies the given graph and returns a new graph with less edges. Convenience method around `sparsify(double, String)` Passing newGraphName as `null`
    `PgxFuture<PgxGraph>` | `sparsifyAsync(double e, String newGraphName)` Sparsifies the given graph and returns a new graph with less edges. Convenience method around `sparsify(Collection, Collection, double, String)` Passing vertexProps as `VertexProperty.ALL` edgeProps as `EdgeProperty.ALL`
    `FileGraphConfig` | `store(Format targetFormat, String targetPath)` Blocking version of `storeAsync(Format, String)`.
    `FileGraphConfig` | `store(Format targetFormat, String targetPath, boolean overwrite)` Blocking version of `storeAsync(Format, String, boolean)`.
    `FileGraphConfig` | `store(Format targetFormat, String targetPath, Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, boolean overwrite)` Blocking version of `storeAsync(Format, String, Collection, Collection, boolean)`.
    `PgxFuture<FileGraphConfig>` | `storeAsync(Format targetFormat, String targetPath)`
    `PgxFuture<FileGraphConfig>` | `storeAsync(Format targetFormat, String targetPath, boolean overwrite)`
    `PgxFuture<FileGraphConfig>` | `storeAsync(Format targetFormat, String targetPath, Collection<VertexProperty<?,?>> vertexProps, Collection<EdgeProperty<?>> edgeProps, boolean overwrite)`
    `String` | `toString()`
    `PgxGraph` | `undirect()` Blocking version of `undirectAsync()`.
    `PgxGraph` | `undirect(Collection<VertexProperty<?,?>> vertexProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `undirectAsync()`.
    `PgxGraph` | `undirect(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Blocking version of `undirectAsync()`.
    `PgxGraph` | `undirect(String newGraphName)` Blocking version of `undirectAsync()`.
    `PgxFuture<PgxGraph>` | `undirectAsync()` Convenience method around `undirectAsync(String)` Passing String(newGraphName) as null
    `PgxFuture<PgxGraph>` | `undirectAsync(Collection<VertexProperty<?,?>> vertexProps, PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Create an undirected version of a graph.
    `PgxFuture<PgxGraph>` | `undirectAsync(PgxGraph.MultiEdges multiEdges, PgxGraph.SelfEdges selfEdges, PgxGraph.TrivialVertices trivialVertices, PgxGraph.Mode mode, String newGraphName)` Convenience method for `undirectAsync(Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing Collection(vertexProps) as `VertexProperty.ALL`
    `PgxFuture<PgxGraph>` | `undirectAsync(String newGraphName)` Convenience method around `undirectAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)` Passing MultiEdges as `MultiEdges.KEEP_MULTI_EDGES` SelfEdges as `SelfEdges.KEEP_SELF_EDGES` Trivial Vertices as `TrivialVertices.KEEP_TRIVIALVERTICES` Mode as `Mode.CREATE_COPY`

    - ### Methods inherited from class oracle.pgx.api.PgxManagedObject

      `equals, hashCode`

    - ### Methods inherited from class oracle.pgx.api.Destroyable

      `close, destroy, destroyAsync`

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

- - ### Method Detail

    - #### bipartiteSubGraphFromLeftSet

          @Generated(value="src/python/synchronize.py")
          public BipartiteGraph bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps,
                                                                   Collection<EdgeProperty<?>> edgeProps,
                                                                   VertexSet<?> vertexSet,
                                                                   String newGraphName)
                                                      throws ExecutionException,
                                                             InterruptedException

      Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`. Calls `#bipartiteSubGraphFromLeftSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### bipartiteSubGraphFromLeftSet

          @Generated(value="src/python/synchronize.py")
          public BipartiteGraph bipartiteSubGraphFromLeftSet(Collection<VertexProperty<?,?>> vertexProps,
                                                                   Collection<EdgeProperty<?>> edgeProps,
                                                                   VertexSet<?> vertexSet,
                                                                   String newGraphName,
                                                                   String isLeftPropName)
                                                      throws ExecutionException,
                                                             InterruptedException

      Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`. Calls `#bipartiteSubGraphFromLeftSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### bipartiteSubGraphFromLeftSet

          @Generated(value="src/python/synchronize.py")
          public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet)
                                                      throws ExecutionException,
                                                             InterruptedException

      Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`. Calls `#bipartiteSubGraphFromLeftSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### bipartiteSubGraphFromLeftSet

          @Generated(value="src/python/synchronize.py")
          public BipartiteGraph bipartiteSubGraphFromLeftSet(VertexSet<?> vertexSet,
                                                                   String newGraphName)
                                                      throws ExecutionException,
                                                             InterruptedException

      Blocking version of `#bipartiteSubGraphFromLeftSetAsync()`. Calls `#bipartiteSubGraphFromLeftSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### bipartiteSubGraphFromLeftSetAsync

          public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps,
                                                                    Collection<EdgeProperty<?>> edgeProps,
                                                                    VertexSet<?> vertexSet,
                                                                    String newGraphName)

      Create a bipartite version of a graph.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `vertexSet` - vertex set representing the left side
        `newGraphName` - name of the new graph. If null, a name will be generated.
        `isLeftPropName` - after the method finishes, the name that will be associated with a boolean property that will contain the information whether a node is on the left side of the bipartite subgraph. The name must not be a name of an existing node property for this graph. If the argument is null, a new unique name will be created.
      Returns:
        resulting graph

    - #### bipartiteSubGraphFromLeftSetAsync

          public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(Collection<VertexProperty<?,?>> vertexProps,
                                                                    Collection<EdgeProperty<?>> edgeProps,
                                                                    VertexSet<?> vertexSet,
                                                                    String newGraphName,
                                                                    String isLeftPropName)

    - #### bipartiteSubGraphFromLeftSetAsync

          public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet)

      Create a bipartite version of a graph.
      `#bipartiteSubGraphFromLeftSet(Collection, Collection, VertexSet)`
      Passing
      - vertexProps as `VertexProperty.ALL`
      - edgeProps as `EdgeProperty.ALL`
      Parameters:
        `vertexSet` - vertex set representing the left side
      Returns:
        resulting graph

    - #### bipartiteSubGraphFromLeftSetAsync

          public PgxFuture<BipartiteGraph> bipartiteSubGraphFromLeftSetAsync(VertexSet<?> vertexSet,
                                                                    String newGraphName)

      Create a bipartite version of a graph.
      Convenience method around `bipartiteSubGraphFromLeftSetAsync(Collection, Collection, VertexSet, String, String)` passing newGraphName and isLeftPropName as `null`
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `vertexSet` - vertex set representing the left side
      Returns:
        resulting graph

    - #### clone

          @Generated(value="src/python/synchronize.py")
          public PgxGraph clone()

      Blocking version of `cloneAsync()`. Calls `cloneAsync()` and waits for the returned `PgxFuture` to complete.
      Overrides:
        `clone` in class `Object`
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### clone

          @Generated(value="src/python/synchronize.py")
          public PgxGraph clone(Collection<VertexProperty<?,?>> vertexProps,
                                      Collection<EdgeProperty<?>> edgeProps,
                                      String newGraphName)
                         throws ExecutionException,
                                InterruptedException

      Blocking version of `cloneAsync()`. Calls `cloneAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### clone

          @Generated(value="src/python/synchronize.py")
          public PgxGraph clone(String newGraphName)
                         throws ExecutionException,
                                InterruptedException

      Blocking version of `cloneAsync()`. Calls `cloneAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### cloneAsync

          public PgxFuture<PgxGraph> cloneAsync()

      Convenience method of `cloneAsync(String)`
      Passing
      - String(name) as `null`
      Create a copy of a graph.
      Returns:
        resulting graph

    - #### cloneAsync

          public PgxFuture<PgxGraph> cloneAsync(Collection<VertexProperty<?,?>> vertexProps,
                                       Collection<EdgeProperty<?>> edgeProps,
                                       String newGraphName)

      Create a copy of a graph.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### cloneAsync

          public PgxFuture<PgxGraph> cloneAsync(String newGraphName)

      Convenience method of `cloneAsync(Collection, Collection, String)`
      Passing
      - Collection(vertexProperties) as `VertexProperty.ALL`
      - Collection(edgeProperties) as `EdgeProperty.ALL`
      Create a copy of a graph.
      Parameters:
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### createAllPaths

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> createAllPaths(PgxVertex<ID> src,
                                                                               EdgeProperty<Double> cost,
                                                                               VertexProperty<ID,PgxVertex<ID>> parent,
                                                                               VertexProperty<ID,PgxEdge> parentEdge)
                                                             throws ExecutionException,
                                                                    InterruptedException

      Blocking version of `#createAllPathsAsync()`. Calls `#createAllPathsAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createAllPathsAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> createAllPathsAsync(PgxVertex<ID> src,
                                                                                EdgeProperty<Double> cost,
                                                                                VertexProperty<ID,PgxVertex<ID>> parent,
                                                                                VertexProperty<ID,PgxEdge> parentEdge)

      Creates a `AllPaths` object representing all the shortest paths from a single source to all the possible destinations (shortest regarding the given edge costs).
      Parameters:
        `src` - source vertex
        `cost` - property holding the edge costs. If `null`, the resulting cost will equal the hop distance.
        `parent` - property holding the parent vertices of all the shortest paths. For example, if the source vertex is A and the shortest path to C is A -> B -> C, then then parent[C] -> B and parent[B] -> A.
        `parentEdge` - property holding the parent edges for each vertex shortest path
      Returns:
        the `AllPaths` object.

    - #### createComponents

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Partition<ID> createComponents(VertexProperty<ID,Integer> components,
                                                                                  int numComponents)
                                                                throws ExecutionException,
                                                                       InterruptedException

      Blocking version of `#createComponentsAsync()`. Calls `#createComponentsAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createComponentsAsync

          public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> createComponentsAsync(VertexProperty<ID,Integer> components,
                                                                                   int numComponents)

      Creates a `Partition` object holding a collection of vertex sets, each representing a component.
      Parameters:
        `components` - property mapping each vertex to its component ID. Note that only component IDs in the range of [0..numComponents-1] are allowed. The returned future will complete exceptionally with an `IllegalArgumentException` if an invalid component ID is encountered. Gaps are supported: certain IDs not being associated with any vertices will yield to empty components.
        `numComponents` - how many different components the components property contains
      Returns:
        the `Partition` object.

    - #### createEdgeProperty

          @Generated(value="src/python/synchronize.py")
          public <V extends Comparable<V>> EdgeProperty<V> createEdgeProperty(PropertyType type)
                                                                   throws ExecutionException,
                                                                          InterruptedException

      Blocking version of `#createEdgePropertyAsync()`. Calls `#createEdgePropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgeProperty

          @Generated(value="src/python/synchronize.py")
          public <V extends Comparable<V>> EdgeProperty<V> createEdgeProperty(PropertyType type,
                                                                                    String name)
                                                                   throws ExecutionException,
                                                                          InterruptedException

      Blocking version of `#createEdgePropertyAsync()`. Calls `#createEdgePropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgePropertyAsync

          public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> createEdgePropertyAsync(PropertyType type)

      Creates a session-bound edge property
      Parameters:
        `type` - type of property to create
      Returns:
        newly created property

    - #### createEdgePropertyAsync

          public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> createEdgePropertyAsync(PropertyType type,
                                                                                     String name)

      Creates a session-bound edge property
      Parameters:
        `type` - type of property to create
        `name` - of property to be created
      Returns:
        newly created property

    - #### createEdgeSequence

          @Generated(value="src/python/synchronize.py")
          public EdgeSequence createEdgeSequence()
                                          throws ExecutionException,
                                                 InterruptedException

      Blocking version of `createEdgeSequenceAsync()`. Calls `createEdgeSequenceAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgeSequence

          @Generated(value="src/python/synchronize.py")
          public EdgeSequence createEdgeSequence(String name)
                                          throws ExecutionException,
                                                 InterruptedException

      Blocking version of `createEdgeSequenceAsync()`. Calls `createEdgeSequenceAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgeSequenceAsync

          public PgxFuture<EdgeSequence> createEdgeSequenceAsync()

      Creates a new Edge Sequence.
      Returns:
        the newly created Edge Sequence

    - #### createEdgeSequenceAsync

          public PgxFuture<EdgeSequence> createEdgeSequenceAsync(String name)

      Creates a new Edge Sequence.
      Parameters:
        `name` - name of the Edge Sequence to be created
      Returns:
        the newly created Edge Sequence

    - #### createEdgeSet

          @Generated(value="src/python/synchronize.py")
          public EdgeSet createEdgeSet()
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `createEdgeSetAsync()`. Calls `createEdgeSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgeSet

          @Generated(value="src/python/synchronize.py")
          public EdgeSet createEdgeSet(String name)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `createEdgeSetAsync()`. Calls `createEdgeSetAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createEdgeSetAsync

          public PgxFuture<EdgeSet> createEdgeSetAsync()

      Creates a new Edge Set.
      Returns:
        the newly created EdgeSet

    - #### createEdgeSetAsync

          public PgxFuture<EdgeSet> createEdgeSetAsync(String name)

      Creates a new Edge Set.
      Parameters:
        `name` - name of the Edge Set to be created
      Returns:
        the newly created EdgeSet

    - #### createMap

          @Generated(value="src/python/synchronize.py")
          public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                               PropertyType valType)
                                                                            throws ExecutionException,
                                                                                   InterruptedException

      Blocking version of `#createMapAsync()`. Calls `#createMapAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createMap

          @Generated(value="src/python/synchronize.py")
          public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                               PropertyType valType,
                                                                                               MapType mapType)
                                                                            throws ExecutionException,
                                                                                   InterruptedException

      Blocking version of `#createMapAsync()`. Calls `#createMapAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createMap

          @Generated(value="src/python/synchronize.py")
          public <K extends Comparable<K>,V extends Comparable<V>> PgxMap<K,V> createMap(PropertyType keyType,
                                                                                               PropertyType valType,
                                                                                               MapType mapType,
                                                                                               String mapName)
                                                                            throws ExecutionException,
                                                                                   InterruptedException

      Blocking version of `#createMapAsync()`. Calls `#createMapAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createMapAsync

          public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                                PropertyType valType)

      Creates a session-bound map
      Parameters:
        `keyType` - Property type of the keys that are going to be stored inside the map
        `valType` - Property type of the values that are going to be stored inside the map
      Returns:
        newly created map

    - #### createMapAsync

          public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                                PropertyType valType,
                                                                                                MapType mapType)

      Creates a session-bound map
      Parameters:
        `keyType` - Property type of the keys that are going to be stored inside the map
        `valType` - Property type of the values that are going to be stored inside the map
        `mapType` - Type of the map that is going to be created
      Returns:
        newly created map

    - #### createMapAsync

          public <K extends Comparable<K>,V extends Comparable<V>> PgxFuture<PgxMap<K,V>> createMapAsync(PropertyType keyType,
                                                                                                PropertyType valType,
                                                                                                MapType mapType,
                                                                                                String mapName)

      Creates a session-bound map
      Parameters:
        `keyType` - Property type of the keys that are going to be stored inside the map
        `valType` - Property type of the values that are going to be stored inside the map
        `mapType` - Type of the map that is going to be created
        `mapName` - how the map should be named
      Returns:
        newly created map

    - #### createPath

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxPath<ID> createPath(PgxVertex<ID> src,
                                                                          PgxVertex<ID> dst,
                                                                          EdgeProperty<Double> cost,
                                                                          VertexProperty<ID,PgxVertex<ID>> parent,
                                                                          VertexProperty<ID,PgxEdge> parentEdge)
                                                        throws ExecutionException,
                                                               InterruptedException

      Blocking version of `#createPathAsync()`. Calls `#createPathAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createPathAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> createPathAsync(PgxVertex<ID> src,
                                                                           PgxVertex<ID> dst,
                                                                           EdgeProperty<Double> cost,
                                                                           VertexProperty<ID,PgxVertex<ID>> parent,
                                                                           VertexProperty<ID,PgxEdge> parentEdge)

      Creates a `PgxPath` object representing the shortest path from one source to one destination (shortest regarding the given edge costs). If there are multiple shortest paths, an arbitrary one will be returned.
      Parameters:
        `src` - source vertex of the path
        `dst` - destination vertex of the path
        `cost` - property holding the edge costs. If `null`, the resulting cost will equal the hop distance.
        `parent` - property holding the parent vertices for each vertex of the shortest path. For example, if the shortest path is A -> B -> C, then parent[C] -> B and parent[B] -> A.
        `parentEdge` - property holding the parent edges for each vertex of the shortest path
      Returns:
        the `PgxPath` object.

    - #### createScalar

          @Generated(value="src/python/synchronize.py")
          public <T> Scalar<T> createScalar(PropertyType type)
                                 throws ExecutionException,
                                        InterruptedException

      Blocking version of `#createScalarAsync()`. Calls `#createScalarAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createScalar

          @Generated(value="src/python/synchronize.py")
          public <T> Scalar<T> createScalar(PropertyType type,
                                                  String newScalarName)
                                 throws ExecutionException,
                                        InterruptedException

      Blocking version of `#createScalarAsync()`. Calls `#createScalarAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createScalarAsync

          public <T> PgxFuture<Scalar<T>> createScalarAsync(PropertyType type)

      Creates a new Scalar.
      Parameters:
        `type` - the Property Type
      Returns:
        newly created Scalar.

    - #### createScalarAsync

          public <T> PgxFuture<Scalar<T>> createScalarAsync(PropertyType type,
                                                   String newScalarName)

      Create a session-bound scalar.
      Parameters:
        `newScalarName` - name of the scalar to be created
        `type` - the type of scalar
      Returns:
        the newly created scalar

    - #### createVertexProperty

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> createVertexProperty(PropertyType type)
                                                                                                 throws ExecutionException,
                                                                                                        InterruptedException

      Blocking version of `#createVertexPropertyAsync()`. Calls `#createVertexPropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexProperty

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> createVertexProperty(PropertyType type,
                                                                                                                     String name)
                                                                                                 throws ExecutionException,
                                                                                                        InterruptedException

      Blocking version of `#createVertexPropertyAsync()`. Calls `#createVertexPropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexPropertyAsync

          public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> createVertexPropertyAsync(PropertyType type)

      Creates a session-bound vertex property
      Parameters:
        `type` - type of the property to create
      Returns:
        newly created property

    - #### createVertexPropertyAsync

          public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> createVertexPropertyAsync(PropertyType type,
                                                                                                                      String name)

      Creates a session-bound vertex property
      Parameters:
        `type` - type of property to create
        `name` - of property to be created
      Returns:
        newly created property

    - #### createVertexSequence

          @Generated(value="src/python/synchronize.py")
          public <E extends Comparable<E>> VertexSequence<E> createVertexSequence()
                                                                       throws ExecutionException,
                                                                              InterruptedException

      Blocking version of `createVertexSequenceAsync()`. Calls `createVertexSequenceAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexSequence

          @Generated(value="src/python/synchronize.py")
          public <E extends Comparable<E>> VertexSequence<E> createVertexSequence(String name)
                                                                       throws ExecutionException,
                                                                              InterruptedException

      Blocking version of `createVertexSequenceAsync()`. Calls `createVertexSequenceAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexSequenceAsync

          public <E extends Comparable<E>> PgxFuture<VertexSequence<E>> createVertexSequenceAsync()

      Creates a new Vertex Sequence.
      Returns:
        newly created VertexSequence

    - #### createVertexSequenceAsync

          public <E extends Comparable<E>> PgxFuture<VertexSequence<E>> createVertexSequenceAsync(String name)

      Creates a new Vertex Sequence.
      Parameters:
        `name` - the name of the collection to be created
      Returns:
        newly created VertexSequence

    - #### createVertexSet

          @Generated(value="src/python/synchronize.py")
          public <E extends Comparable<E>> VertexSet<E> createVertexSet()
                                                             throws ExecutionException,
                                                                    InterruptedException

      Blocking version of `createVertexSetAsync()`. Calls `createVertexSetAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexSet

          @Generated(value="src/python/synchronize.py")
          public <E extends Comparable<E>> VertexSet<E> createVertexSet(String name)
                                                             throws ExecutionException,
                                                                    InterruptedException

      Blocking version of `createVertexSetAsync()`. Calls `createVertexSetAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### createVertexSetAsync

          public <E extends Comparable<E>> PgxFuture<VertexSet<E>> createVertexSetAsync()

      Creates a new Vertex Set.
      Returns:
        the newly created Vertex Set

    - #### createVertexSetAsync

          public <E extends Comparable<E>> PgxFuture<VertexSet<E>> createVertexSetAsync(String name)

      Creates a new Vertex Set.
      Parameters:
        `name` - name of the vertex set to be created
      Returns:
        the newly created Vertex Set

    - #### filter

          @Generated(value="src/python/synchronize.py")
          public PgxGraph filter(Collection<VertexProperty<?,?>> vertexProps,
                                       Collection<EdgeProperty<?>> edgeProps,
                                       GraphFilter graphFilter,
                                       String newGraphName)
                          throws ExecutionException,
                                 InterruptedException

      Blocking version of `#filterAsync()`. Calls `#filterAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### filter

          @Generated(value="src/python/synchronize.py")
          public PgxGraph filter(GraphFilter graphFilter)
                          throws ExecutionException,
                                 InterruptedException

      Blocking version of `#filterAsync()`. Calls `#filterAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### filter

          @Generated(value="src/python/synchronize.py")
          public PgxGraph filter(GraphFilter graphFilter,
                                       String newGraphName)
                          throws ExecutionException,
                                 InterruptedException

      Blocking version of `#filterAsync()`. Calls `#filterAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### filterAsync

          public PgxFuture<PgxGraph> filterAsync(Collection<VertexProperty<?,?>> vertexProps,
                                        Collection<EdgeProperty<?>> edgeProps,
                                        GraphFilter graphFilter,
                                        String newGraphName)

      Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `graphFilter` - GraphFilter object representing a filter expression that is applied to create the subgraph
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### filterAsync

          public PgxFuture<PgxGraph> filterAsync(GraphFilter graphFilter)

      Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
      Convenience method around `filterAsync(GraphFilter, String)`
      Passing
      - newGraphName as `null`
      Parameters:
        `graphFilter` - GraphFilter object representing a filter expression that is applied to create the subgraph
      Returns:
        resulting graph

    - #### filterAsync

          public PgxFuture<PgxGraph> filterAsync(GraphFilter graphFilter,
                                        String newGraphName)

      Create a subgraph of a graph. To create the subgraph, a given filter expression is used to determine which parts of the graph will be part of the subgraph.
      Convenience method around `filterAsync(Collection, Collection, GraphFilter, String)`
      Passing
      - vertexProps as `VertexProperty.ALL`
      - edgeProps as `EdgeProperty.ALL`
      Parameters:
        `graphFilter` - GraphFilter object representing a filter expression that is applied to create the subgraph
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### getConfig

          public GraphConfig getConfig()

      Gets the graph configuration object used to specify the data source of this graph.
      Returns:
        the config. Can be `null` if graph was not created from a datasource (`isTransient()` is `true`).

    - #### getCreationRequestTimestamp

          public long getCreationRequestTimestamp()

      Gets the timestamp when this graph was requested to be created.
      Returns:
        the timestamp when this graph was requested to be created in milliseconds since Jan 1st, 1970 (UTC).

    - #### getCreationTimestamp

          public long getCreationTimestamp()

      Gets the timestamp when this graph finished creation.
      Returns:
        the timestamp when this graph finished creation in milliseconds since Jan 1st, 1970 (UTC).

    - #### getDataSourceVersion

          public String getDataSourceVersion()

      Gets the format-specific version identifier provided by data-source (timestamp for files, snapshot ID for databases).
      Returns:
        the dataSourceVersion. Can be `null` if graph was not created from a datasource ( `isTransient()` is `true`).

    - #### getEdge

          public PgxEdge getEdge(long id)

      Gets a `PgxEdge` of this graph by ID. Note that this method does *not* check whether the given ID exists.
      Parameters:
        `id` - the ID of the vertex
      Returns:
        the `PgxEdge` object

    - #### getEdgeProperties

          @Generated(value="src/python/synchronize.py")
          public Set<EdgeProperty<?>> getEdgeProperties()
                                                 throws ExecutionException,
                                                        InterruptedException

      Blocking version of `getEdgePropertiesAsync()`. Calls `getEdgePropertiesAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getEdgePropertiesAsync

          public PgxFuture<Set<EdgeProperty<?>>> getEdgePropertiesAsync()

      Get the set of edge properties belonging to this graph. This list might contain transient properties.
      Returns:
        all edge properties of this graph

    - #### getEdgeProperty

          @Generated(value="src/python/synchronize.py")
          public <V extends Comparable<V>> EdgeProperty<V> getEdgeProperty(String name)
                                                                throws ExecutionException,
                                                                       InterruptedException

      Blocking version of `#getEdgePropertyAsync()`. Calls `#getEdgePropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getEdgePropertyAsync

          public <V extends Comparable<V>> PgxFuture<EdgeProperty<V>> getEdgePropertyAsync(String name)

      get an edge property of this graph
      Parameters:
        `name` - the name of the edge property
      Returns:
        the edge property object or `null` if no such property exists
      Throws:
        `NullPointerException` - if the passed name is null

    - #### getEdges

          @Generated(value="src/python/synchronize.py")
          public EdgeSet getEdges(EdgeFilter filter)
                           throws InterruptedException,
                                  ExecutionException

      Blocking version of `#getEdges()`. Calls `#getEdges()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getEdgesAsync

          public <E extends Comparable<E>> PgxFuture<EdgeSet> getEdgesAsync(EdgeFilter filter)

      Creates a new Edge Set containing edges according to the given filter expression.
      Parameters:
        `filter` - the edge filter expression used to create the Edge Set
      Returns:
        newly created Edge Set

    - #### getMemoryMb

          public long getMemoryMb()

      Gets the estimated number of memory this graph (including its properties) consumes in memory (in megabytes).
      Returns:
        the memoryMb

    - #### getName

          public String getName()

      Specified by:
        `getName` in class `PgxManagedObject`
      Returns:
        the name of the graph

    - #### getNumEdges

          public long getNumEdges()

      Gets the number of edges
      Returns:
        the numEdges

    - #### getNumVertices

          public long getNumVertices()

      Gets the number of vertices
      Returns:
        the numVertices

    - #### getPgxInstance

          public ServerInstance getPgxInstance()

      Returns:
        returns the current instance of PGX

    - #### getSession

          public PgxSession getSession()

      Returns:
        returns the current session of PGX

    - #### getVertex

          public <ID extends Comparable<ID>> PgxVertex<ID> getVertex(ID id)

      Gets a `PgxVertex` of this graph by ID. Note that this method does *not* check whether the given ID exists.
      Parameters:
        `id` - the ID of the vertex
      Returns:
        the `PgxVertex` object
      Throws:
        `IllegalArgumentException` - if given ID is `null` or not of type `IdType`

    - #### getVertexIdType

          public IdType getVertexIdType()

      Gets the vertex ID type of this graph.
      Returns:
        the vertexIdType

    - #### getVertexProperties

          @Generated(value="src/python/synchronize.py")
          public Set<VertexProperty<?,?>> getVertexProperties()
                                                       throws ExecutionException,
                                                              InterruptedException

      Blocking version of `getVertexPropertiesAsync()`. Calls `getVertexPropertiesAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getVertexPropertiesAsync

          public PgxFuture<Set<VertexProperty<?,?>>> getVertexPropertiesAsync()

      Get the set of vertex properties belonging to this graph. This list might contain transient properties.
      Returns:
        all vertex properties of this graph

    - #### getVertexProperty

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>,V extends Comparable<V>> VertexProperty<ID,V> getVertexProperty(String name)
                                                                                              throws ExecutionException,
                                                                                                     InterruptedException

      Blocking version of `#getVertexPropertyAsync()`. Calls `#getVertexPropertyAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getVertexPropertyAsync

          public <ID extends Comparable<ID>,V extends Comparable<V>> PgxFuture<VertexProperty<ID,V>> getVertexPropertyAsync(String name)

      Gets a vertex property of this graph
      Parameters:
        `name` - the name of the vertex property
      Returns:
        the vertex property object or `null` if no such property exists
      Throws:
        `NullPointerException` - if the passed name is null

    - #### getVertices

          @Generated(value="src/python/synchronize.py")
          public <E extends Comparable<E>> VertexSet<E> getVertices(VertexFilter filter)
                                                         throws InterruptedException,
                                                                ExecutionException

      Blocking version of `#getVerticesAsync()`. Calls `#getVerticesAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### getVerticesAsync

          public <E extends Comparable<E>> PgxFuture<VertexSet<E>> getVerticesAsync(VertexFilter filter)

      Creates a new Vertex Set containing vertices according to the given filter expression.
      Parameters:
        `filter` - the vertex filter expression used to create the Vertex Set
      Returns:
        newly created Vertex Set

    - #### isFresh

          @Generated(value="src/python/synchronize.py")
          public boolean isFresh()
                          throws ExecutionException,
                                 InterruptedException

      Blocking version of `isFreshAsync()`. Calls `isFreshAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### isFreshAsync

          public PgxFuture<Boolean> isFreshAsync()

      Check whether an in-memory representation of a graph is fresh. If the given graph is not the latest snapshot in memory the method will return false. If the given graph is the latest snapshot in memory, its snapshot version gets compared to the latest version reported by datasource (SCN for databases, last-modified timestamp for files). If the given graph is transient (private, session-bound), it is always considered fresh.
      Returns:
        true if given graph is fresh, false otherwise

    - #### isTransient

          public boolean isTransient()

      Returns:
        `true` if this graph is transient (session-bound, private), `false` otherwise.

    - #### pickRandomVertex

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxVertex<ID> pickRandomVertex()
                                                                throws ExecutionException,
                                                                       InterruptedException

      Blocking version of `pickRandomVertexAsync()`. Calls `pickRandomVertexAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### pickRandomVertexAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxVertex<ID>> pickRandomVertexAsync()

      Picks a random vertex in the graph.
      Returns:
        a random vertex.

    - #### simplify

          @Generated(value="src/python/synchronize.py")
          public PgxGraph simplify(Collection<VertexProperty<?,?>> vertexProps,
                                         Collection<EdgeProperty<?>> edgeProps,
                                         PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `#simplifyAsync()`. Calls `#simplifyAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### simplify

          @Generated(value="src/python/synchronize.py")
          public PgxGraph simplify(PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `#simplifyAsync()`. Calls `#simplifyAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### simplifyAsync

          public PgxFuture<PgxGraph> simplifyAsync(Collection<VertexProperty<?,?>> vertexProps,
                                          Collection<EdgeProperty<?>> edgeProps,
                                          PgxGraph.MultiEdges multiEdges,
                                          PgxGraph.SelfEdges selfEdges,
                                          PgxGraph.TrivialVertices trivialVertices,
                                          PgxGraph.Mode mode,
                                          String newGraphName)

      Create a simplified version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `multiEdges` - defines if multi-edges should be kept in the result. Constants `PgxGraph.MultiEdges.KEEP_MULTI_EDGES` or `PgxGraph.MultiEdges.REMOVE_MULTI_EDGES` can be used
        `selfEdges` - defines if self-edges should be kept in the result. Constants `PgxGraph.SelfEdges.KEEP_SELF_EDGES` or `PgxGraph.SelfEdges.REMOVE_SELF_EDGES` cane be used.
        `trivialVertices` - defines if isolated nodes should be kept in the result. Constants `PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES` or `PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES` can be used
        `mode` - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` can be used
        `newGraphName` - name of the new graph (only relevant if mode == `PgxGraph.Mode.CREATE_COPY` ). If null, a name will be generated.
      Returns:
        resulting graph

    - #### simplifyAsync

          public PgxFuture<PgxGraph> simplifyAsync(PgxGraph.MultiEdges multiEdges,
                                          PgxGraph.SelfEdges selfEdges,
                                          PgxGraph.TrivialVertices trivialVertices,
                                          PgxGraph.Mode mode,
                                          String newGraphName)

      Convenience method for `simplifyAsync(Collection, Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)`
      Passing
      - Collection(vertexProperties) as `VertexProperty.ALL`
      - Collection(edgeProperties) as `EdgeProperty.ALL`
      Create a simplified version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies.
      Parameters:
        `multiEdges` - defines if multi-edges should be kept in the result. Constants `PgxGraph.MultiEdges.KEEP_MULTI_EDGES` or `PgxGraph.MultiEdges.REMOVE_MULTI_EDGES` can be used
        `selfEdges` - defines if self-edges should be kept in the result. Constants `PgxGraph.SelfEdges.KEEP_SELF_EDGES` or `PgxGraph.SelfEdges.REMOVE_SELF_EDGES` cane be used.
        `trivialVertices` - defines if isolated nodes should be kept in the result. Constants `PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES` or `PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES` can be used
        `mode` - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` can be used
        `newGraphName` - name of the new graph (only relevant if mode == `PgxGraph.Mode.CREATE_COPY` ). If null, a name will be generated.
      Returns:
        resulting graph

    - #### sortByDegree

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sortByDegree()
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `sortByDegreeAsync()`. Calls `sortByDegreeAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sortByDegree

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sortByDegree(Collection<VertexProperty<?,?>> vertexProps,
                                             Collection<EdgeProperty<?>> edgeProps,
                                             PgxGraph.Direction direction,
                                             PgxGraph.Degree degree,
                                             PgxGraph.Mode mode,
                                             String newGraphName)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `sortByDegreeAsync()`. Calls `sortByDegreeAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sortByDegree

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sortByDegree(PgxGraph.Direction direction,
                                             PgxGraph.Degree degree,
                                             PgxGraph.Mode mode,
                                             String newGraphName)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `sortByDegreeAsync()`. Calls `sortByDegreeAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sortByDegree

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sortByDegree(String newGraphName)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `sortByDegreeAsync()`. Calls `sortByDegreeAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sortByDegreeAsync

          public PgxFuture<PgxGraph> sortByDegreeAsync()

      Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
      Convenience method around `sortByDegree(String)`
      Passing newGraphName as `null`
      Returns:
        newly created graph

    - #### sortByDegreeAsync

          public PgxFuture<PgxGraph> sortByDegreeAsync(Collection<VertexProperty<?,?>> vertexProps,
                                              Collection<EdgeProperty<?>> edgeProps,
                                              PgxGraph.Direction direction,
                                              PgxGraph.Degree degree,
                                              PgxGraph.Mode mode,
                                              String newGraphName)

      Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `direction` - order direction. Constants `PgxGraph.Direction.ASCENDING` or `PgxGraph.Direction.DESCENDING` should be used
        `degree` - degree sorting mode. Constants `PgxGraph.Degree.OUT` or `PgxGraph.Degree.IN` should be used
        `mode` - it specifies if the graph should be mutated in place or a new one should be created. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` should be used
        `newGraphName` - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
      Returns:
        newly created graph

    - #### sortByDegreeAsync

          public PgxFuture<PgxGraph> sortByDegreeAsync(PgxGraph.Direction direction,
                                              PgxGraph.Degree degree,
                                              PgxGraph.Mode mode,
                                              String newGraphName)

      Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
      Convenience method around `sortByDegreeAsync(Collection, Collection, Direction, Degree, Mode, String)`
      Passing
      - Collection(vertexProps) as `VertexProperty.ALL`
      - Collection(edgeProps) as `EdgeProperty.ALL`
      Parameters:
        `direction` - order direction. Constants `PgxGraph.Direction.ASCENDING` or `PgxGraph.Direction.DESCENDING` should be used
        `degree` - degree sorting mode. Constants `PgxGraph.Degree.OUT` or `PgxGraph.Degree.IN` should be used
        `mode` - it specifies if the graph should be mutated in place or a new one should be created. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` should be used
        `newGraphName` - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
      Returns:
        newly created graph

    - #### sortByDegreeAsync

          public PgxFuture<PgxGraph> sortByDegreeAsync(String newGraphName)

      Create a sorted version of a graph and all its properties. The returned graph is sorted such that the node numbering is ordered by the degree of the nodes. Note that the returned graph and properties are transient.
      Convenience method around `sortByDegree(Direction, Degree, Mode, String)`
      Passing
      - Direction as `Direction.DESCENDING`
      - Degree as `Degree.IN`
      - Mode as `Mode.CREATE_COPY`
      Parameters:
        `newGraphName` - name of the new graph (only relevant if a new copy is being created). If null, a name will be generated.
      Returns:
        newly created graph

    - #### sparsify

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sparsify(Collection<VertexProperty<?,?>> vertexProps,
                                         Collection<EdgeProperty<?>> edgeProps,
                                         double e,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `#sparsifyAsync()`. Calls `#sparsifyAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sparsify

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sparsify(double e)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `#sparsifyAsync()`. Calls `#sparsifyAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sparsify

          @Generated(value="src/python/synchronize.py")
          public PgxGraph sparsify(double e,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `#sparsifyAsync()`. Calls `#sparsifyAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sparsifyAsync

          public PgxFuture<PgxGraph> sparsifyAsync(Collection<VertexProperty<?,?>> vertexProps,
                                          Collection<EdgeProperty<?>> edgeProps,
                                          double e,
                                          String newGraphName)

      Sparsifies the given graph and returns a new graph with less edges. The underlying algorithm is based on the paper by V. Satuluri, S. Parthasarathy, Y. Ruan: 'Local Graph Sparsification for Scalable Clustering'.
      Parameters:
        `vertexProps` - vertex properties belonging to graph specified by graph to be transformed as well. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `edgeProps` - edge properties belonging to graph specified by graph to be transformed as well. Constants `EdgeProperty.ALL` or `EdgeProperty.NONE` can be used.
        `e` - the sparsification coefficient
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### sparsifyAsync

          public PgxFuture<PgxGraph> sparsifyAsync(double e)

      Sparsifies the given graph and returns a new graph with less edges.
      Convenience method around `sparsify(double, String)`
      Passing
      - newGraphName as `null`
      Parameters:
        `e` - the sparsification coefficient
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### sparsifyAsync

          public PgxFuture<PgxGraph> sparsifyAsync(double e,
                                          String newGraphName)

      Sparsifies the given graph and returns a new graph with less edges.
      Convenience method around `sparsify(Collection, Collection, double, String)`
      Passing
      - vertexProps as `VertexProperty.ALL`
      - edgeProps as `EdgeProperty.ALL`
      Parameters:
        `e` - the sparsification coefficient. Must be between 0.0 and 1.1.
        `newGraphName` - name of the new graph. If null, a name will be generated.
      Returns:
        resulting graph

    - #### store

          @Generated(value="src/python/synchronize.py")
          public FileGraphConfig store(Format targetFormat,
                                             String targetPath)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `storeAsync(Format, String)`. Calls `storeAsync(Format, String)` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### store

          @Generated(value="src/python/synchronize.py")
          public FileGraphConfig store(Format targetFormat,
                                             String targetPath,
                                             boolean overwrite)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `storeAsync(Format, String, boolean)`. Calls `storeAsync(Format, String, boolean)` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### store

          @Generated(value="src/python/synchronize.py")
          public FileGraphConfig store(Format targetFormat,
                                             String targetPath,
                                             Collection<VertexProperty<?,?>> vertexProps,
                                             Collection<EdgeProperty<?>> edgeProps,
                                             boolean overwrite)
                                throws ExecutionException,
                                       InterruptedException

      Blocking version of `storeAsync(Format, String, Collection, Collection, boolean)`. Calls `storeAsync(Format, String, Collection, Collection, boolean)` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### storeAsync

          public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                              String targetPath)

    - #### storeAsync

          public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                              String targetPath,
                                              boolean overwrite)

    - #### storeAsync

          public PgxFuture<FileGraphConfig> storeAsync(Format targetFormat,
                                              String targetPath,
                                              Collection<VertexProperty<?,?>> vertexProps,
                                              Collection<EdgeProperty<?>> edgeProps,
                                              boolean overwrite)

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `PgxManagedObject`

    - #### undirect

          @Generated(value="src/python/synchronize.py")
          public PgxGraph undirect()
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `undirectAsync()`. Calls `undirectAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### undirect

          @Generated(value="src/python/synchronize.py")
          public PgxGraph undirect(Collection<VertexProperty<?,?>> vertexProps,
                                         PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `undirectAsync()`. Calls `undirectAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### undirect

          @Generated(value="src/python/synchronize.py")
          public PgxGraph undirect(PgxGraph.MultiEdges multiEdges,
                                         PgxGraph.SelfEdges selfEdges,
                                         PgxGraph.TrivialVertices trivialVertices,
                                         PgxGraph.Mode mode,
                                         String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `undirectAsync()`. Calls `undirectAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### undirect

          @Generated(value="src/python/synchronize.py")
          public PgxGraph undirect(String newGraphName)
                            throws ExecutionException,
                                   InterruptedException

      Blocking version of `undirectAsync()`. Calls `undirectAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### undirectAsync

          public PgxFuture<PgxGraph> undirectAsync()

      Convenience method around `undirectAsync(String)` Passing String(newGraphName) as null
      Returns:
        the resulting graph

    - #### undirectAsync

          public PgxFuture<PgxGraph> undirectAsync(Collection<VertexProperty<?,?>> vertexProps,
                                          PgxGraph.MultiEdges multiEdges,
                                          PgxGraph.SelfEdges selfEdges,
                                          PgxGraph.TrivialVertices trivialVertices,
                                          PgxGraph.Mode mode,
                                          String newGraphName)

      Create an undirected version of a graph. Note that the returned graph and properties are transient and therefore session bound. They can be explicitly destroyed and get automatically freed once the session dies. Undirecting edge properties is currently not supported.
      Parameters:
        `vertexProps` - vertex properties belonging to graph. Constants `VertexProperty.ALL` or `VertexProperty.NONE` can be used.
        `multiEdges` - defines if multi-edges should be kept in the result. Constants `PgxGraph.MultiEdges.KEEP_MULTI_EDGES` or `PgxGraph.MultiEdges.REMOVE_MULTI_EDGES` can be used
        `selfEdges` - defines if self-edges should be kept in the result. Constants `PgxGraph.SelfEdges.KEEP_SELF_EDGES` or `PgxGraph.SelfEdges.REMOVE_SELF_EDGES` cane be used.
        `trivialVertices` - defines if isolated nodes should be kept in the result. Constants `PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES` or `PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES` can be used
        `mode` - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` can be used
        `newGraphName` - name of the new graph (only relevant if mode == `PgxGraph.Mode.CREATE_COPY` ). If null, a name will be generated.
      Returns:
        resulting graph

    - #### undirectAsync

          public PgxFuture<PgxGraph> undirectAsync(PgxGraph.MultiEdges multiEdges,
                                          PgxGraph.SelfEdges selfEdges,
                                          PgxGraph.TrivialVertices trivialVertices,
                                          PgxGraph.Mode mode,
                                          String newGraphName)

      Convenience method for `undirectAsync(Collection, MultiEdges, SelfEdges, TrivialVertices, Mode, String)`
      Passing Collection(vertexProps) as `VertexProperty.ALL`
      Parameters:
        `multiEdges` - defines if multi-edges should be kept in the result.
        `selfEdges` - defines if self-edges should be kept in the result. Constants `PgxGraph.SelfEdges.KEEP_SELF_EDGES` or `PgxGraph.SelfEdges.REMOVE_SELF_EDGES` cane be used.
        `trivialVertices` - defines if isolated nodes should be kept in the result. Constants `PgxGraph.TrivialVertices.KEEP_TRIVIAL_VERTICES` or `PgxGraph.TrivialVertices.REMOVE_TRIVIAL_VERTICES` can be used
        `mode` - defines if a copy of the graph should be created, otherwise graph is mutated in place. Constants `PgxGraph.Mode.MUTATE_IN_PLACE` or `PgxGraph.Mode.CREATE_COPY` can be used
        `newGraphName` - name of the new graph (only relevant if mode == `PgxGraph.Mode.CREATE_COPY` ). If null, a name will be generated.
      Returns:
        resulting graph

    - #### undirectAsync

          public PgxFuture<PgxGraph> undirectAsync(String newGraphName)

      Convenience method around `undirectAsync(MultiEdges, SelfEdges, TrivialVertices, Mode, String)`
      Passing
      - MultiEdges as `MultiEdges.KEEP_MULTI_EDGES`
      - SelfEdges as `SelfEdges.KEEP_SELF_EDGES`
      - Trivial Vertices as `TrivialVertices.KEEP_TRIVIALVERTICES`
      - Mode as `Mode.CREATE_COPY`
      Parameters:
        `newGraphName` - name of the new graph (only relevant if mode == `PgxGraph.Mode.CREATE_COPY` ). If null, a name will be generated.
      Returns:
        resulting graph

Copyright © 2015. All rights reserved.